import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {
        test_Comparator();
        test_String_Comparator();
        test_map();
    }

    static void test_Comparator() {
        String[] array = new String[] { "Apple", "Orange", "Banana", "Lemon" };
        Comparator<String> c1 = (s1, s2) -> s1.compareTo(s2);
        Arrays.sort(array, c1);
        System.out.println(String.join(", ", array));
    }

    static void test_String_Comparator() {
        String[] array = new String[] { "Apple", "Orange", "Banana", "Lemon" };
        Arrays.sort(array, String::compareTo);
        System.out.println(String.join(", ", array));

        // public final class String {
        // public int compareTo(String o) {
        // ...
        // }
        // }
        // 这个方法的签名只有一个参数，为什么和int Comparator<String>.compare(String, String)能匹配呢？
        // 因为实例方法有一个隐含的this参数，String类的compareTo()方法在实际调用的时候，第一个隐含参数总是传入this，相当于静态方法：
        // public static int compareTo(String this, String o);
    }

    static void test_map() {
        List<String> names = List.of("Bob", "Alice", "Tim");
        List<Person> persons = names.stream().map(Person::new).collect(Collectors.toList());
        System.out.println(persons);

        // 你写的
        // names.stream().map(Person::new)
        // // 编译器实际帮你生成
        // names.stream().map(new Function<String, Person>() {
        // @Override
        // public Person apply(String s) {
        // return new Person(s); // 直接调用构造方法
        // }
        // })
        // Person::new 被当成 “工厂方法” 看待，签名恰好匹配 Function<String, Person>
    }

}

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }

    public String toString() {
        return "Person:" + this.name;
    }
}